home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / misc_src / cslib16b / include / csfield.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-01  |  8.2 KB  |  399 lines
  1. /***********************************************************************
  2.  
  3.                                        CSA Library, Version 1.6.b 
  4.                                          Released: March 2nd 1995 
  5.  
  6.        Defining FIELD classes for every type of variable.
  7.  
  8.                                            Copyright(c) 1994,1995 
  9.                                                            Combis 
  10.                                                   The Netherlands 
  11. ***********************************************************************/
  12.  
  13. #ifndef __CSFIELD_H
  14. #define __CSFIELD_H
  15.  
  16. #ifndef __CSDATE_H
  17.   #include "csdate.h"
  18. #endif
  19.  
  20. #ifndef __CSTOOLS_H
  21.   #include "cstools.h"
  22. #endif
  23.  
  24. #ifndef __CSEDSTR_H
  25.   #include "csedstr.h"
  26. #endif
  27.  
  28. #ifndef __CSWINDOW_H
  29.   #include "cswindow.h"
  30. #endif
  31.  
  32. #pragma warn -sig
  33. #pragma warn -hid
  34.  
  35. enum f_protect { EDIT,DISPLAY,BROWSE };
  36.  
  37.  
  38. class FIELD: public WINDOW, public EDSTR
  39. {
  40.  
  41.  
  42. ////////////////////////// Variables  //////////////////////////////////////////
  43.  
  44. protected:
  45.   int protects;
  46.   int exitfield;
  47.   void *po;
  48.   int e_insert;
  49.   int e_l_pos;
  50.   int e_pos;
  51.   CSCHAR *val_exp;    // validation expression
  52.   uchar  *s_template;    // template string
  53.  
  54.  
  55.  
  56. ////////////////////////// Protected functions /////////////////////////////////
  57.  
  58. protected:
  59.  
  60.    int (FIELD::*edit_fun)(void);
  61.    void check_displen(void);
  62.    int    read(void)         { return (this->*edit_fun)(); }
  63.    int    browse_w(void);
  64.    int    edit_w(void);
  65.    int    edit_tpt(void);
  66.  
  67.    virtual int i_insert(void);
  68.    virtual int max_ok(void) =0;
  69.    virtual int min_ok(void) =0;
  70.    virtual int is_valid(void)  { return TRUE; }
  71.  
  72.  
  73. public:
  74.  
  75.  
  76. ////////////////////////////////////////////////////////////////////////
  77. ////////////////////// PUBLIC FUNCTIONS ////////////////////////////////
  78. ////////////////////////////////////////////////////////////////////////
  79.  
  80.  
  81.  
  82. //////////////////////// Template & Validation /////////////////////////
  83.    void validate(CSCHAR *s)  { val_exp=s;    }
  84.    void picture(CSCHAR *s);
  85.    void picture_off(void);
  86.  
  87.  
  88.  
  89. /////////////////////// Editing ////////////////////////////////////////
  90.     int edit(void)       { v_exit(FALSE); return read(); }
  91.     int edit_v(void)       { v_exit(TRUE);  return read(); }
  92.    void init_e_pos(void)   { e_insert=-1; e_l_pos=-1; e_pos=-1; }
  93.  
  94.    int browse(void)       { v_exit(FALSE); return browse_w(); }
  95.    int browse_v(void)       { v_exit(TRUE);  return browse_w(); }
  96.  
  97.  
  98.  
  99. /////////////////////// Defining fields ////////////////////////////////
  100.    void field_color(int col) { screen_color(col); }
  101.    void protect(int t)       { protects=t; }
  102.    int    protect(void)       { return protects; }
  103.    void show(void);
  104.  
  105.    void exit_field(int tf) { exitfield=tf; }
  106.    int    exit_field(void)   { return exitfield; }
  107.  
  108.  
  109. ////////////////////////Con&Des-structor ///////////////////////////////
  110.    FIELD(void);
  111.    virtual ~FIELD(void);
  112.  
  113.  
  114. /////////////////////// Max & Min functions ////////////////////////////
  115.    virtual void set_max(int);
  116.    virtual void set_max(long);
  117.    virtual void set_max(float);
  118.    virtual void set_max(double);
  119.    virtual void set_max(CSCHAR *);
  120.    virtual void set_max(CSCHAR);
  121.    virtual void set_max(DATE &);
  122.  
  123.    virtual void set_min(int);
  124.    virtual void set_min(long);
  125.    virtual void set_min(float);
  126.    virtual void set_min(double);
  127.    virtual void set_min(CSCHAR *);
  128.    virtual void set_min(CSCHAR);
  129.    virtual void set_min(DATE &);
  130.  
  131.    virtual void reset_max(void)=0;
  132.    virtual void reset_min(void)=0;
  133.  
  134.  
  135.  
  136.  
  137. /////////////////////// Operator overloading ///////////////////////////
  138.  
  139.    void operator=(CSCHAR *s);
  140.    void operator=(CSCHAR &c);
  141.    void operator=(int &i);
  142.    void operator=(long &l);
  143.    void operator=(float &f);
  144.    void operator=(double &d);
  145.    void operator=(DATE &d);
  146.  
  147.  
  148. ////////////////////////// Miscellaneous ///////////////////////////////////////
  149.  
  150.    virtual void recreate(void) =0;
  151.    virtual int restore(void)=0;
  152.  
  153. };
  154.  
  155.  
  156.  
  157. //////////////////////////// int FIELD /////////////////////////////////
  158.  
  159.  
  160. class iFIELD: public FIELD
  161. {
  162.  
  163. private:
  164.  
  165.    int maxi;
  166.    int mini;
  167.  
  168.  
  169. protected:
  170.  
  171.    int max_ok(void);
  172.    int min_ok(void);
  173.    int restore(void)        { return convert(*(int *)po); }
  174.    virtual int is_valid(void);
  175.    void recreate(void)        { }
  176.  
  177. public:
  178.  
  179.    iFIELD(void);
  180.    void set_max(int    i)      { maxi=i; }
  181.    void set_min(int    i)      { mini=i; }
  182.    void set_max(long   i)      { maxi=i; }
  183.    void set_min(long   i)      { mini=i; }
  184.    void set_max(float  i)      { maxi=i; }
  185.    void set_min(float  i)      { mini=i; }
  186.    void set_max(double i)      { maxi=i; }
  187.    void set_min(double i)      { mini=i; }
  188.    void reset_max(void);
  189.    void reset_min(void);
  190.  
  191. };
  192.  
  193.  
  194.  
  195. //////////////////////////// long FIELD /////////////////////////////////
  196.  
  197.  
  198. class lFIELD: public FIELD
  199. {
  200.  
  201. private:
  202.  
  203.    long maxi;
  204.    long mini;
  205.  
  206.  
  207. protected:
  208.  
  209.    int max_ok(void);
  210.    int min_ok(void);
  211.    int restore(void)        { return convert(*(long *)po); }
  212.    virtual int is_valid(void);
  213.    void recreate(void)        { }
  214.  
  215. public:
  216.  
  217.    lFIELD(void);
  218.    void set_max(int    i)      { maxi=i; }
  219.    void set_min(int    i)      { mini=i; }
  220.    void set_max(long   i)      { maxi=i; }
  221.    void set_min(long   i)      { mini=i; }
  222.    void set_max(float  i)      { maxi=i; }
  223.    void set_min(float  i)      { mini=i; }
  224.    void set_max(double i)      { maxi=i; }
  225.    void set_min(double i)      { mini=i; }
  226.    void reset_max(void);
  227.    void reset_min(void);
  228.  
  229. };
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237. //////////////////////////// double FIELD /////////////////////////////////
  238.  
  239.  
  240. class dFIELD: public FIELD
  241. {
  242.  
  243. private:
  244.  
  245.    double maxi;
  246.    double mini;
  247.  
  248.  
  249. protected:
  250.  
  251.    int max_ok(void);
  252.    int min_ok(void);
  253.    int restore(void)        { return convert(*(double *)po); }
  254.    virtual int is_valid(void);
  255.    void recreate(void)        { }
  256.  
  257. public:
  258.  
  259.    dFIELD(void);
  260.    void set_max(int    i)      { maxi=i; }
  261.    void set_min(int    i)      { mini=i; }
  262.    void set_max(long   i)      { maxi=i; }
  263.    void set_min(long   i)      { mini=i; }
  264.    void set_max(float  i)      { maxi=i; }
  265.    void set_min(float  i)      { mini=i; }
  266.    void set_max(double i)      { maxi=i; }
  267.    void set_min(double i)      { mini=i; }
  268.    void reset_max(void);
  269.    void reset_min(void);
  270.  
  271. };
  272.  
  273.  
  274.  
  275. //////////////////////////// float FIELD /////////////////////////////////
  276.  
  277.  
  278. class fFIELD: public dFIELD
  279. {
  280.  
  281.  
  282. protected:
  283.    int restore(void)        { return convert(*(float *)po); }
  284.    void recreate(void)        { }
  285.  
  286. public:
  287.     fFIELD(void);
  288.  
  289.  
  290. };
  291.  
  292.  
  293.  
  294. //////////////////////////// string FIELD /////////////////////////////////
  295.  
  296.  
  297. class sFIELD: public FIELD
  298. {
  299.  
  300. private:
  301.  
  302.    CSCHAR * maxi;
  303.    CSCHAR * mini;
  304.  
  305.  
  306. protected:
  307.    int max_ok(void);
  308.    int min_ok(void);
  309.    int restore(void)        { return convert((CSCHAR *)po); }
  310.    void recreate(void)        { FIELD::operator=(((CSCHAR *)po)); }
  311.  
  312. public:
  313.  
  314.    sFIELD(void);
  315.    void set_max(CSCHAR *s)    { maxi=s; }
  316.    void set_min(CSCHAR *s)    { mini=s; }
  317.    void reset_max(void);
  318.    void reset_min(void);
  319.  
  320. };
  321.  
  322.  
  323.  
  324. //////////////////////////// CSCHAR FIELD //////////////////////////////////
  325.  
  326.  
  327. class cFIELD: public FIELD
  328. {
  329.  
  330. private:
  331.  
  332.    CSCHAR  maxi;
  333.    CSCHAR  mini;
  334.  
  335.  
  336. protected:
  337.  
  338.    int max_ok(void);
  339.    int min_ok(void);
  340.    int restore(void)        { return convert(*(CSCHAR *)po); }
  341.    virtual int i_insert(void)    { return FALSE; }
  342.    void recreate(void)        { }
  343.  
  344. public:
  345.  
  346.    cFIELD(void);
  347.    void set_max(CSCHAR i)     { maxi=i; }
  348.    void set_min(CSCHAR i)     { mini=i; }
  349.    void reset_max(void);
  350.    void reset_min(void);
  351.  
  352. };
  353.  
  354. //////////////////////////// date FIELD //////////////////////////////////
  355.  
  356.  
  357. class aFIELD: public FIELD
  358. {
  359.  
  360. private:
  361.  
  362.    DATE  maxi;
  363.    DATE  mini;
  364.  
  365.  
  366. protected:
  367.  
  368.    int max_ok(void);
  369.    int min_ok(void);
  370.    int restore(void)        { *((DATE *)po)=(CSCHAR *)s; return TRUE; }
  371.    virtual int i_insert(void)    { return FALSE; }
  372.    virtual int is_valid(void);
  373.    void recreate(void)        { FIELD::operator=(*(DATE *)po); }
  374.  
  375. public:
  376.  
  377.    aFIELD(void);
  378.    void set_max(DATE &);
  379.    void set_min(DATE &);
  380.     void set_max(CSCHAR *s);
  381.     void set_min(CSCHAR *s);
  382.     void reset_max(void);
  383.     void reset_min(void);
  384.  
  385. };
  386.  
  387.  
  388. #pragma warn .sig
  389. #pragma warn .hid
  390.  
  391.  
  392. #endif
  393.  
  394.  
  395.  
  396.  
  397.  
  398.  
  399.